package com.yf.repo.modules.qu.utils;

import com.yf.base.api.exception.ServiceException;
import com.yf.base.utils.AbcTags;
import com.yf.base.utils.BeanMapper;
import com.yf.repo.enums.QuType;
import com.yf.repo.modules.qu.dto.QuAnswerDTO;
import com.yf.repo.modules.qu.dto.export.QuExportDTO;
import com.yf.repo.modules.qu.dto.ext.QuDetailDTO;
import com.yf.repo.modules.repo.service.RepoChapterService;
import com.yf.system.modules.dict.service.SysDicValueService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 进行数据转换，用来导入导出的
 *
 * @author van
 */
@Component
public class QuConvert {

    @Autowired
    private SysDicValueService sysDicValueService;

    @Autowired
    private RepoChapterService repoChapterService;

    private static final String TYPE_FILL = "填空题";
    private static final String TYPE_JUDGE = "判断题";
    private static final String JUDGE_YES = "正确";
    private static final String JUDGE_NO = "错误";
    /**
     * 填空题有序或无序
     */
    private static final String FILL_SORT = "有序";
    private static final String FILL_NO_SORT = "无序";




    /**
     * 导入：将导入的excel转换成详情以便于插入数据库
     *
     * @param list
     * @param repoId
     * @return
     * @throws ServiceException
     */
    public List<QuDetailDTO> prepareImport(List<QuExportDTO> list, String repoId) throws ServiceException {

        List<QuDetailDTO> importList = new ArrayList<>();

        Map<String, String> typeMap = sysDicValueService.findDictMap("qu_type");
        Map<String, String> levelMap = sysDicValueService.findDictMap("qu_level");
        Map<String, String> chapterMap = repoChapterService.findMap(repoId);


        // 组合题主题目
        List<QuDetailDTO> subList = new ArrayList<>();
        QuDetailDTO mix = null;

        for (QuExportDTO item : list) {

            QuDetailDTO dto = this.parseQu(item, typeMap, levelMap, chapterMap);
            dto.setRepoId(repoId);

            // 组合题开始构建组合项目
            if (QuType.MIX.equals(dto.getQuType())) {

                // 上题组合题
                if (!CollectionUtils.isEmpty(subList) && mix != null) {
                    mix.setSubList(subList);
                    importList.add(mix);
                }

                // 重新清理准备下一题
                mix = BeanMapper.map(dto, QuDetailDTO.class);
                subList = new ArrayList<>();
                continue;
            }

            // 是则增加子项目
            if (StringUtils.isNotBlank(item.getMixItem()) && "是".equals(item.getMixItem().trim())) {
                subList.add(dto);
            } else {

                // 加入组合题
                if (!CollectionUtils.isEmpty(subList) && mix != null) {
                    mix.setSubList(subList);
                    importList.add(mix);

                    // 清理准备下一题
                    mix = BeanMapper.map(dto, QuDetailDTO.class);
                    subList = new ArrayList<>();
                }

                // 本题内容
                importList.add(dto);
            }
        }

        // 当列表只有一个组合题时，残留项目导入
        if (!CollectionUtils.isEmpty(subList) && mix != null) {
            mix.setSubList(subList);
            importList.add(mix);
        }

        return importList;
    }

    /**
     * 导入：转换题目信息
     *
     * @param dto
     * @return
     */
    private QuDetailDTO parseQu(QuExportDTO dto, Map<String, String> typeMap, Map<String, String> levelMap, Map<String, String> chapterMap) {


        // 判断题型
        String typeTitle = dto.getQuType().trim();

        if (!typeMap.containsKey(typeTitle)) {
            throw new ServiceException("题型：" + typeTitle + "不存在，请确认！");
        }

        String typeValue = typeMap.get(typeTitle);

        // 填充数据
        QuDetailDTO resDTO = new QuDetailDTO();
        resDTO.setContent(dto.getContent());
        resDTO.setQuType(typeValue);
        resDTO.setLevel(levelMap.get(dto.getLevel()));
        resDTO.setAnalysis(dto.getAnalysis());
        resDTO.setChapterId(chapterMap.get(dto.getChapter()));
        resDTO.setCreateTime(new Date());


        // 备选项列表
        List<String> items = new ArrayList<>();

        // 单选多项填空提取值
        if(QuType.RADIO.equals(typeValue) || QuType.MULTI.equals(typeValue)){
            items = this.fillItem(dto);
        }

        // 填空题
        if(QuType.FILL.equals(typeValue)){
            items = this.fillItem(dto);
            // 有序或无序
            resDTO.setAnswerOrder(FILL_SORT.equals(dto.getAnswer()));
        }

        // 判断题自动添加两个项目
        if(QuType.JUDGE.equals(typeValue)){
            items.add(JUDGE_YES);
            items.add(JUDGE_NO);
        }

        // 简答题和组合题不需要备选项
        if(QuType.SAQ.equals(typeValue) || QuType.MIX.equals(typeValue)){
            return resDTO;
        }

        // 备选项不能为空
        if (CollectionUtils.isEmpty(items)) {
            throw new ServiceException(MessageFormat.format("题目：【{0}】，客观题至少要包含一个备选答案！", resDTO.getContentText()));
        }

        List<QuAnswerDTO> answers = new ArrayList<>();

        for (int i = 0; i < items.size(); i++) {
            // ABC
            String tag = AbcTags.get(i);
            // 选项内容
            String content = items.get(i);
            QuAnswerDTO item = new QuAnswerDTO();
            // 是否正确答案
            item.setIsRight(this.isAnswer(tag, dto.getAnswer(), content));
            item.setContent(content);
            answers.add(item);
        }

        // 简答题和组合题不需要备选项
        if((QuType.RADIO.equals(typeValue)
                || QuType.MULTI.equals(typeValue)
                || QuType.JUDGE.equals(typeValue))
                && !this.checkAnswer(answers)){
            throw new ServiceException(MessageFormat.format("题目：【{0}】，必须定义选项是否正确项！", resDTO.getContentText()));
        }

        resDTO.setAnswerList(answers);
        return resDTO;

    }

    /**
     * 导入：判断是否正确项
     *
     * @param tag
     * @param answer
     * @return
     */
    private boolean isAnswer(String tag, String answer, String content) {

        // 选择题正确错误
        if (!StringUtils.isBlank(answer)) {
            if(answer.toUpperCase().contains(tag)){
                return true;
            }

            if(!StringUtils.isBlank(content) && answer.equals(content)){
                return true;
            }
        }
        return false;
    }


    /**
     * 单选、多选、判断必须给答案
     * @param answers
     * @return
     */
    private boolean checkAnswer(List<QuAnswerDTO> answers){

        for(QuAnswerDTO dto: answers){
            if(dto.getIsRight()!=null && dto.getIsRight()){
                return true;
            }
        }
        return false;
    }


    /**
     * 导出：构建导出数据
     *
     * @param respList
     * @param list
     * @param mix
     */
    public void buildExport(List<QuExportDTO> respList, List<QuDetailDTO> list, boolean mix) {

        for (QuDetailDTO item : list) {
            QuExportDTO dto = new QuExportDTO();
            // 题型名称
            String quType = sysDicValueService.findDictText("qu_type", item.getQuType());
            dto.setQuType(quType);
            dto.setMixItem(mix ? "是" : "否");

            // 级别名称
            String quLevel = sysDicValueService.findDictText("qu_level", item.getLevel());
            dto.setLevel(quLevel);

            // 章节名称
            String chapterTitle = sysDicValueService.findTableText("el_repo_chapter", "title", "id", item.getChapterId());
            dto.setChapter(chapterTitle);
            dto.setContent(item.getContent());
            // 构建选项
            dto.setAnalysis(item.getAnalysis());
            // 构建选项和正确答案items,answer
            this.buildItems(dto, item.getAnswerList());

            // 填空题有序无序
            if(item.getAnswerOrder()!=null && QuType.FILL.equals(item.getQuType())){
                dto.setAnswer(item.getAnswerOrder()?FILL_SORT: FILL_NO_SORT);
            }
            // 先加入大题
            respList.add(dto);
            // 再次构建子题目
            if (QuType.MIX.equals(item.getQuType())) {
                List<QuDetailDTO> subList = item.getSubList();
                if (!CollectionUtils.isEmpty(subList)) {
                    this.buildExport(respList, subList, true);
                }
            }
        }
    }

    /**
     * 导出：构建选项和正确答案
     *
     * @param export
     * @param answerList
     */
    private void buildItems(QuExportDTO export, List<QuAnswerDTO> answerList) {

        // 处理选项
        StringBuffer answer = new StringBuffer();
        int i = 0;
        for (QuAnswerDTO dto : answerList) {

            // 判断题不需要增加项目
            if(!TYPE_JUDGE.equals(export.getQuType())) {

                switch (i) {
                    case 0:
                        export.setItemA(dto.getContent());
                        break;
                    case 1:
                        export.setItemB(dto.getContent());
                        break;
                    case 2:
                        export.setItemC(dto.getContent());
                        break;
                    case 3:
                        export.setItemD(dto.getContent());
                        break;
                    case 4:
                        export.setItemE(dto.getContent());
                        break;
                    case 5:
                        export.setItemF(dto.getContent());
                        break;
                    case 6:
                        export.setItemG(dto.getContent());
                        break;
                    case 7:
                        export.setItemH(dto.getContent());
                        break;
                    default:
                        break;
                }
            }

            if (dto.getIsRight()) {
                // 判断题直接写答案
                if(TYPE_JUDGE.equals(export.getQuType())){
                    answer.append(dto.getContent());
                }else{
                    answer.append(AbcTags.get(i));
                }
            }
            i++;
        }

        // 填空题不需要
        if(!TYPE_FILL.equals(export.getQuType())){
            export.setAnswer(answer.toString());
        }

    }


    /**
     * 提取客观题选项
     * @param dto
     * @return
     */
    private List<String> fillItem(QuExportDTO dto){

        // 备选项列表
        List<String> items = new ArrayList();

        if(StringUtils.isNotBlank(dto.getItemA())){
            items.add(dto.getItemA());
        }
        if(StringUtils.isNotBlank(dto.getItemB())){
            items.add(dto.getItemB());
        }
        if(StringUtils.isNotBlank(dto.getItemC())){
            items.add(dto.getItemC());
        }
        if(StringUtils.isNotBlank(dto.getItemD())){
            items.add(dto.getItemD());
        }
        if(StringUtils.isNotBlank(dto.getItemE())){
            items.add(dto.getItemE());
        }
        if(StringUtils.isNotBlank(dto.getItemF())){
            items.add(dto.getItemF());
        }
        if(StringUtils.isNotBlank(dto.getItemG())){
            items.add(dto.getItemG());
        }
        if(StringUtils.isNotBlank(dto.getItemH())){
            items.add(dto.getItemH());
        }

        return items;
    }
}
